home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / CIncludes / DriverServices.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-17  |  17.5 KB  |  694 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        DriverServices.h
  3.  
  4.      Contains:    Driver Services Interfaces.
  5.  
  6.      Version:    Technology:    PowerSurge 1.0.2
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __DRIVERSERVICES__
  18. #define __DRIVERSERVICES__
  19.  
  20. #ifndef __CONDITIONALMACROS__
  21. #include <ConditionalMacros.h>
  22. #endif
  23. #ifndef __MACTYPES__
  24. #include <MacTypes.h>
  25. #endif
  26. #ifndef __ERRORS__
  27. #include <Errors.h>
  28. #endif
  29. #ifndef __MACHINEEXCEPTIONS__
  30. #include <MachineExceptions.h>
  31. #endif
  32. #ifndef __DEVICES__
  33. #include <Devices.h>
  34. #endif
  35. #ifndef __DRIVERSYNCHRONIZATION__
  36. #include <DriverSynchronization.h>
  37. #endif
  38.  
  39.  
  40.  
  41. #if PRAGMA_ONCE
  42. #pragma once
  43. #endif
  44.  
  45. #ifdef __cplusplus
  46. extern "C" {
  47. #endif
  48.  
  49. #if PRAGMA_IMPORT
  50. #pragma import on
  51. #endif
  52.  
  53. #if PRAGMA_STRUCT_ALIGN
  54.     #pragma options align=power
  55. #elif PRAGMA_STRUCT_PACKPUSH
  56.     #pragma pack(push, 2)
  57. #elif PRAGMA_STRUCT_PACK
  58.     #pragma pack(2)
  59. #endif
  60.  
  61. /******************************************************************
  62.  *
  63.  *         Previously in Kernel.h
  64.  *
  65.  ******************************************************************/
  66. /* Kernel basics*/
  67. typedef struct OpaqueIOPreparationID*     IOPreparationID;
  68. typedef struct OpaqueSoftwareInterruptID*  SoftwareInterruptID;
  69. typedef struct OpaqueTaskID*             TaskID;
  70. typedef struct OpaqueTimerID*             TimerID;
  71. /* OrderedItem stuff*/
  72. typedef OSType                             OrderedItemService;
  73. typedef OSType                             OrderedItemSignature;
  74.  
  75. enum {
  76.     kMatchAnyOrderedItemService    = FOUR_CHAR_CODE('****'),
  77.     kMatchAnyOrderedItemSignature = FOUR_CHAR_CODE('****'),
  78.     kDoNotMatchAnyOrderedItemService = FOUR_CHAR_CODE('----'),
  79.     kDoNotMatchAnyOrderedItemSignature = FOUR_CHAR_CODE('----')
  80. };
  81.  
  82.  
  83. struct OrderedItemName {
  84.     OrderedItemService                 service;
  85.     OrderedItemSignature             signature;
  86. };
  87. typedef struct OrderedItemName            OrderedItemName;
  88. typedef OrderedItemName *                OrderedItemNamePtr;
  89.  
  90. typedef OptionBits                         OrderedItemOptions;
  91.  
  92. enum {
  93.     kOrderedItemIsRightBefore    = 0x00000001,
  94.     kOrderedItemIsRightAfter    = 0x00000002
  95. };
  96.  
  97.  
  98. struct OrderRequirements {
  99.     OrderedItemOptions                 options;
  100.     OrderedItemName                 itemBefore;
  101.     OrderedItemName                 itemAfter;
  102. };
  103. typedef struct OrderRequirements        OrderRequirements;
  104. typedef OrderRequirements *                OrderRequirementsPtr;
  105. /* Tasking*/
  106.  
  107. typedef UInt32                             ExecutionLevel;
  108.  
  109. enum {
  110.     kTaskLevel                    = 0,
  111.     kSoftwareInterruptLevel        = 1,
  112.     kAcceptFunctionLevel        = 2,
  113.     kKernelLevel                = 3,
  114.     kSIHAcceptFunctionLevel        = 4,
  115.     kSecondaryInterruptLevel    = 5,
  116.     kHardwareInterruptLevel        = 6
  117. };
  118.  
  119. typedef CALLBACK_API_C( void , SoftwareInterruptHandler )(void *p1, void *p2);
  120. typedef CALLBACK_API_C( OSStatus , SecondaryInterruptHandler2 )(void *p1, void *p2);
  121. #define kCurrentAddressSpaceID ((AddressSpaceID) -1)
  122.  
  123. /* Memory System basics*/
  124.  
  125. struct LogicalAddressRange {
  126.     LogicalAddress                     address;
  127.     ByteCount                         count;
  128. };
  129. typedef struct LogicalAddressRange        LogicalAddressRange;
  130. typedef LogicalAddressRange *            LogicalAddressRangePtr;
  131.  
  132. struct PhysicalAddressRange {
  133.     PhysicalAddress                 address;
  134.     ByteCount                         count;
  135. };
  136. typedef struct PhysicalAddressRange        PhysicalAddressRange;
  137. typedef PhysicalAddressRange *            PhysicalAddressRangePtr;
  138. /* For PrepareMemoryForIO and CheckpointIO*/
  139.  
  140. typedef OptionBits                         IOPreparationOptions;
  141.  
  142. enum {
  143.     kIOMultipleRanges            = 0x00000001,
  144.     kIOLogicalRanges            = 0x00000002,
  145.     kIOMinimalLogicalMapping    = 0x00000004,
  146.     kIOShareMappingTables        = 0x00000008,
  147.     kIOIsInput                    = 0x00000010,
  148.     kIOIsOutput                    = 0x00000020,
  149.     kIOCoherentDataPath            = 0x00000040,
  150.     kIOTransferIsLogical        = 0x00000080,
  151.     kIOClientIsUserMode            = 0x00000080
  152. };
  153.  
  154. typedef OptionBits                         IOPreparationState;
  155.  
  156. enum {
  157.     kIOStateDone                = 0x00000001
  158. };
  159.  
  160.  
  161. enum {
  162.     kInvalidPageAddress            = (-1)
  163. };
  164.  
  165.  
  166. struct AddressRange {
  167.     void *                            base;
  168.     ByteCount                         length;
  169. };
  170. typedef struct AddressRange                AddressRange;
  171. /* C's treatment of arrays and array pointers is atypical*/
  172.  
  173. typedef LogicalAddress *                LogicalMappingTablePtr;
  174. typedef PhysicalAddress *                PhysicalMappingTablePtr;
  175. typedef AddressRange *                    AddressRangeTablePtr;
  176.  
  177. struct MultipleAddressRange {
  178.     ItemCount                         entryCount;
  179.     AddressRangeTablePtr             rangeTable;
  180. };
  181. typedef struct MultipleAddressRange        MultipleAddressRange;
  182. /*
  183.    Separate C definition so that union has a name.  A future version of the interfacer
  184.    tool will allow a name (that gets thrown out in Pascal and Asm).
  185. */
  186.  
  187. struct IOPreparationTable {
  188.     IOPreparationOptions             options;
  189.     IOPreparationState                 state;
  190.     IOPreparationID                 preparationID;
  191.     AddressSpaceID                     addressSpace;
  192.     ByteCount                         granularity;
  193.     ByteCount                         firstPrepared;
  194.     ByteCount                         lengthPrepared;
  195.     ItemCount                         mappingEntryCount;
  196.     LogicalMappingTablePtr             logicalMapping;
  197.     PhysicalMappingTablePtr         physicalMapping;
  198.     union {
  199.         AddressRange                     range;
  200.         MultipleAddressRange             multipleRanges;
  201.     }                                 rangeInfo;
  202. };
  203. typedef struct IOPreparationTable        IOPreparationTable;
  204.  
  205. typedef OptionBits                         IOCheckpointOptions;
  206.  
  207. enum {
  208.     kNextIOIsInput                = 0x00000001,
  209.     kNextIOIsOutput                = 0x00000002,
  210.     kMoreIOTransfers            = 0x00000004
  211. };
  212.  
  213. /* For SetProcessorCacheMode*/
  214.  
  215. typedef UInt32                             ProcessorCacheMode;
  216.  
  217. enum {
  218.     kProcessorCacheModeDefault    = 0,
  219.     kProcessorCacheModeInhibited = 1,
  220.     kProcessorCacheModeWriteThrough = 2,
  221.     kProcessorCacheModeCopyBack    = 3
  222. };
  223.  
  224. /*
  225.    For GetPageInformation
  226.    (Note: if kPageInformationVersion fails, try 0 -- old versions of DSL defined  kPageInformationVersion as 0)
  227. */
  228.  
  229.  
  230. enum {
  231.     kPageInformationVersion        = 1
  232. };
  233.  
  234. typedef UInt32                             PageStateInformation;
  235.  
  236. enum {
  237.     kPageIsProtected            = 0x00000001,
  238.     kPageIsProtectedPrivileged    = 0x00000002,
  239.     kPageIsModified                = 0x00000004,
  240.     kPageIsReferenced            = 0x00000008,
  241.     kPageIsLockedResident        = 0x00000010,                    /* held and locked resident*/
  242.     kPageIsInMemory                = 0x00000020,
  243.     kPageIsShared                = 0x00000040,
  244.     kPageIsWriteThroughCached    = 0x00000080,
  245.     kPageIsCopyBackCached        = 0x00000100,
  246.     kPageIsHeldResident            = 0x00000200,                    /* held resident - use kPageIsLockedResident to check for locked state*/
  247.     kPageIsLocked                = kPageIsLockedResident,        /* Deprecated*/
  248.     kPageIsResident                = kPageIsInMemory                /* Deprecated*/
  249. };
  250.  
  251.  
  252. struct PageInformation {
  253.     AreaID                             area;
  254.     ItemCount                         count;
  255.     PageStateInformation             information[1];
  256. };
  257. typedef struct PageInformation            PageInformation;
  258. typedef PageInformation *                PageInformationPtr;
  259.  
  260. /*  Tasks  */
  261. EXTERN_API_C( ExecutionLevel )
  262. CurrentExecutionLevel            (void);
  263.  
  264. EXTERN_API_C( TaskID )
  265. CurrentTaskID                    (void);
  266.  
  267. EXTERN_API_C( OSStatus )
  268. DelayFor                        (Duration                 delayDuration);
  269.  
  270. EXTERN_API_C( Boolean )
  271. InPrivilegedMode                (void);
  272.  
  273.  
  274. /*  Software Interrupts  */
  275. EXTERN_API_C( OSStatus )
  276. CreateSoftwareInterrupt            (SoftwareInterruptHandler  handler,
  277.                                  TaskID                 task,
  278.                                  void *                    p1,
  279.                                  Boolean                 persistent,
  280.                                  SoftwareInterruptID *    theSoftwareInterrupt);
  281.  
  282.  
  283. EXTERN_API_C( OSStatus )
  284. SendSoftwareInterrupt            (SoftwareInterruptID     theSoftwareInterrupt,
  285.                                  void *                    p2);
  286.  
  287. EXTERN_API_C( OSStatus )
  288. DeleteSoftwareInterrupt            (SoftwareInterruptID     theSoftwareInterrupt);
  289.  
  290. #if TARGET_OS_MAC
  291. /*  Secondary Interrupts  */
  292. EXTERN_API_C( OSStatus )
  293. CallSecondaryInterruptHandler2    (SecondaryInterruptHandler2  theHandler,
  294.                                  ExceptionHandler         exceptionHandler,
  295.                                  void *                    p1,
  296.                                  void *                    p2);
  297.  
  298. EXTERN_API_C( OSStatus )
  299. QueueSecondaryInterruptHandler    (SecondaryInterruptHandler2  theHandler,
  300.                                  ExceptionHandler         exceptionHandler,
  301.                                  void *                    p1,
  302.                                  void *                    p2);
  303.  
  304. #endif  /* TARGET_OS_MAC */
  305.  
  306. /*  Timers  */
  307. EXTERN_API_C( OSStatus )
  308. SetInterruptTimer                (const AbsoluteTime *    expirationTime,
  309.                                  SecondaryInterruptHandler2  handler,
  310.                                  void *                    p1,
  311.                                  TimerID *                theTimer);
  312.  
  313. EXTERN_API_C( OSStatus )
  314. CancelTimer                        (TimerID                 theTimer,
  315.                                  AbsoluteTime *            timeRemaining);
  316.  
  317.  
  318. /*  I/O related Operations  */
  319. EXTERN_API_C( OSStatus )
  320. PrepareMemoryForIO                (IOPreparationTable *    theIOPreparationTable);
  321.  
  322. EXTERN_API_C( OSStatus )
  323. CheckpointIO                    (IOPreparationID         theIOPreparation,
  324.                                  IOCheckpointOptions     options);
  325.  
  326.  
  327. /*  Memory Operations  */
  328. EXTERN_API_C( OSStatus )
  329. GetPageInformation                (AddressSpaceID         addressSpace,
  330.                                  ConstLogicalAddress     base,
  331.                                  ByteCount                 length,
  332.                                  PBVersion                 version,
  333.                                  PageInformation *        thePageInfo);
  334.  
  335. /*  Processor Cache Related  */
  336. EXTERN_API_C( OSStatus )
  337. SetProcessorCacheMode            (AddressSpaceID         addressSpace,
  338.                                  ConstLogicalAddress     base,
  339.                                  ByteCount                 length,
  340.                                  ProcessorCacheMode     cacheMode);
  341.  
  342. /******************************************************************
  343.  *
  344.  *         Was in DriverSupport.h or DriverServices.h
  345.  *
  346.  ******************************************************************/
  347. #define    kAAPLDeviceLogicalAddress "AAPL,address"
  348.  
  349. typedef LogicalAddress *                DeviceLogicalAddressPtr;
  350.  
  351. enum {
  352.     durationMicrosecond            = -1L,                            /* Microseconds are negative*/
  353.     durationMillisecond            = 1L,                            /* Milliseconds are positive*/
  354.     durationSecond                = 1000L,                        /* 1000 * durationMillisecond*/
  355.     durationMinute                = 60000L,                        /* 60 * durationSecond,*/
  356.     durationHour                = 3600000L,                        /* 60 * durationMinute,*/
  357.     durationDay                    = 86400000L,                    /* 24 * durationHour,*/
  358.     durationNoWait                = 0L,                            /* don't block*/
  359.     durationForever                = 0x7FFFFFFF                    /* no time limit*/
  360. };
  361.  
  362.  
  363. enum {
  364.     k8BitAccess                    = 0,                            /* access as 8 bit*/
  365.     k16BitAccess                = 1,                            /* access as 16 bit*/
  366.     k32BitAccess                = 2                                /* access as 32 bit*/
  367. };
  368.  
  369. typedef UnsignedWide                     Nanoseconds;
  370.  
  371. EXTERN_API_C( OSErr )
  372. IOCommandIsComplete                (IOCommandID             theID,
  373.                                  OSErr                     theResult);
  374.  
  375. EXTERN_API_C( OSErr )
  376. GetIOCommandInfo                (IOCommandID             theID,
  377.                                  IOCommandContents *    theContents,
  378.                                  IOCommandCode *        theCommand,
  379.                                  IOCommandKind *        theKind);
  380.  
  381. EXTERN_API_C( void )
  382. UpdateDeviceActivity            (RegEntryID *            deviceEntry);
  383.  
  384. EXTERN_API_C( void )
  385. BlockCopy                        (const void *            srcPtr,
  386.                                  void *                    destPtr,
  387.                                  Size                     byteCount);
  388.  
  389. EXTERN_API_C( LogicalAddress )
  390. PoolAllocateResident            (ByteCount                 byteSize,
  391.                                  Boolean                 clear);
  392.  
  393. EXTERN_API_C( OSStatus )
  394. PoolDeallocate                    (LogicalAddress         address);
  395.  
  396. EXTERN_API_C( ByteCount )
  397. GetLogicalPageSize                (void);
  398.  
  399. EXTERN_API_C( ByteCount )
  400. GetDataCacheLineSize            (void);
  401.  
  402. EXTERN_API_C( OSStatus )
  403. FlushProcessorCache                (AddressSpaceID         spaceID,
  404.                                  LogicalAddress         base,
  405.                                  ByteCount                 length);
  406.  
  407. EXTERN_API_C( LogicalAddress )
  408. MemAllocatePhysicallyContiguous    (ByteCount                 byteSize,
  409.                                  Boolean                 clear);
  410.  
  411. EXTERN_API_C( OSStatus )
  412. MemDeallocatePhysicallyContiguous (LogicalAddress         address);
  413.  
  414.  
  415. EXTERN_API_C( AbsoluteTime )
  416. UpTime                            (void);
  417.  
  418. EXTERN_API_C( void )
  419. GetTimeBaseInfo                    (UInt32 *                minAbsoluteTimeDelta,
  420.                                  UInt32 *                theAbsoluteTimeToNanosecondNumerator,
  421.                                  UInt32 *                theAbsoluteTimeToNanosecondDenominator,
  422.                                  UInt32 *                theProcessorToAbsoluteTimeNumerator,
  423.                                  UInt32 *                theProcessorToAbsoluteTimeDenominator);
  424.  
  425.  
  426. EXTERN_API_C( Nanoseconds )
  427. AbsoluteToNanoseconds            (AbsoluteTime             absoluteTime);
  428.  
  429. EXTERN_API_C( Duration )
  430. AbsoluteToDuration                (AbsoluteTime             absoluteTime);
  431.  
  432. EXTERN_API_C( AbsoluteTime )
  433. NanosecondsToAbsolute            (Nanoseconds             nanoseconds);
  434.  
  435. EXTERN_API_C( AbsoluteTime )
  436. DurationToAbsolute                (Duration                 duration);
  437.  
  438. EXTERN_API_C( AbsoluteTime )
  439. AddAbsoluteToAbsolute            (AbsoluteTime             absoluteTime1,
  440.                                  AbsoluteTime             absoluteTime2);
  441.  
  442. EXTERN_API_C( AbsoluteTime )
  443. SubAbsoluteFromAbsolute            (AbsoluteTime             leftAbsoluteTime,
  444.                                  AbsoluteTime             rightAbsoluteTime);
  445.  
  446. EXTERN_API_C( AbsoluteTime )
  447. AddNanosecondsToAbsolute        (Nanoseconds             nanoseconds,
  448.                                  AbsoluteTime             absoluteTime);
  449.  
  450. EXTERN_API_C( AbsoluteTime )
  451. AddDurationToAbsolute            (Duration                 duration,
  452.                                  AbsoluteTime             absoluteTime);
  453.  
  454. EXTERN_API_C( AbsoluteTime )
  455. SubNanosecondsFromAbsolute        (Nanoseconds             nanoseconds,
  456.                                  AbsoluteTime             absoluteTime);
  457.  
  458. EXTERN_API_C( AbsoluteTime )
  459. SubDurationFromAbsolute            (Duration                 duration,
  460.                                  AbsoluteTime             absoluteTime);
  461.  
  462. EXTERN_API_C( Nanoseconds )
  463. AbsoluteDeltaToNanoseconds        (AbsoluteTime             leftAbsoluteTime,
  464.                                  AbsoluteTime             rightAbsoluteTime);
  465.  
  466. EXTERN_API_C( Duration )
  467. AbsoluteDeltaToDuration            (AbsoluteTime             leftAbsoluteTime,
  468.                                  AbsoluteTime             rightAbsoluteTime);
  469.  
  470. EXTERN_API_C( Nanoseconds )
  471. DurationToNanoseconds            (Duration                 theDuration);
  472.  
  473. EXTERN_API_C( Duration )
  474. NanosecondsToDuration            (Nanoseconds             theNanoseconds);
  475.  
  476.  
  477. EXTERN_API_C( OSErr )
  478. PBQueueInit                        (QHdrPtr                 qHeader);
  479.  
  480. EXTERN_API_C( OSErr )
  481. PBQueueCreate                    (QHdrPtr *                qHeader);
  482.  
  483. EXTERN_API_C( OSErr )
  484. PBQueueDelete                    (QHdrPtr                 qHeader);
  485.  
  486. EXTERN_API_C( void )
  487. PBEnqueue                        (QElemPtr                 qElement,
  488.                                  QHdrPtr                 qHeader);
  489.  
  490. EXTERN_API_C( OSErr )
  491. PBEnqueueLast                    (QElemPtr                 qElement,
  492.                                  QHdrPtr                 qHeader);
  493.  
  494. EXTERN_API_C( OSErr )
  495. PBDequeue                        (QElemPtr                 qElement,
  496.                                  QHdrPtr                 qHeader);
  497.  
  498. EXTERN_API_C( OSErr )
  499. PBDequeueFirst                    (QHdrPtr                 qHeader,
  500.                                  QElemPtr *                theFirstqElem);
  501.  
  502. EXTERN_API_C( OSErr )
  503. PBDequeueLast                    (QHdrPtr                 qHeader,
  504.                                  QElemPtr *                theLastqElem);
  505.  
  506. EXTERN_API_C( char *)
  507. CStrCopy                        (char *                    dst,
  508.                                  const char *            src);
  509.  
  510. EXTERN_API_C( StringPtr )
  511. PStrCopy                        (StringPtr                 dst,
  512.                                  ConstStr255Param         src);
  513.  
  514. EXTERN_API_C( char *)
  515. CStrNCopy                        (char *                    dst,
  516.                                  const char *            src,
  517.                                  UInt32                 max);
  518.  
  519. EXTERN_API_C( StringPtr )
  520. PStrNCopy                        (StringPtr                 dst,
  521.                                  ConstStr255Param         src,
  522.                                  UInt32                 max);
  523.  
  524. EXTERN_API_C( char *)
  525. CStrCat                            (char *                    dst,
  526.                                  const char *            src);
  527.  
  528. EXTERN_API_C( StringPtr )
  529. PStrCat                            (StringPtr                 dst,
  530.                                  ConstStr255Param         src);
  531.  
  532. EXTERN_API_C( char *)
  533. CStrNCat                        (char *                    dst,
  534.                                  const char *            src,
  535.                                  UInt32                 max);
  536.  
  537. EXTERN_API_C( StringPtr )
  538. PStrNCat                        (StringPtr                 dst,
  539.                                  ConstStr255Param         src,
  540.                                  UInt32                 max);
  541.  
  542. EXTERN_API_C( void )
  543. PStrToCStr                        (char *                    dst,
  544.                                  ConstStr255Param         src);
  545.  
  546. EXTERN_API_C( void )
  547. CStrToPStr                        (Str255                 dst,
  548.                                  const char *            src);
  549.  
  550. EXTERN_API_C( SInt16 )
  551. CStrCmp                            (const char *            s1,
  552.                                  const char *            s2);
  553.  
  554. EXTERN_API_C( SInt16 )
  555. PStrCmp                            (ConstStr255Param         str1,
  556.                                  ConstStr255Param         str2);
  557.  
  558. EXTERN_API_C( SInt16 )
  559. CStrNCmp                        (const char *            s1,
  560.                                  const char *            s2,
  561.                                  UInt32                 max);
  562.  
  563. EXTERN_API_C( SInt16 )
  564. PStrNCmp                        (ConstStr255Param         str1,
  565.                                  ConstStr255Param         str2,
  566.                                  UInt32                 max);
  567.  
  568. EXTERN_API_C( UInt32 )
  569. CStrLen                            (const char *            src);
  570.  
  571. EXTERN_API_C( UInt32 )
  572. PStrLen                            (ConstStr255Param         src);
  573.  
  574. EXTERN_API_C( OSStatus )
  575. DeviceProbe                        (void *                    theSrc,
  576.                                  void *                    theDest,
  577.                                  UInt32                 AccessType);
  578.  
  579. EXTERN_API_C( OSStatus )
  580. DelayForHardware                (AbsoluteTime             absoluteTime);
  581.  
  582.  
  583.  
  584. /******************************************************************
  585.  *
  586.  *         Was in Interrupts.h 
  587.  *
  588.  ******************************************************************/
  589. /*  Interrupt types  */
  590. typedef struct OpaqueInterruptSetID*     InterruptSetID;
  591. typedef long                             InterruptMemberNumber;
  592.  
  593. struct InterruptSetMember {
  594.     InterruptSetID                     setID;
  595.     InterruptMemberNumber             member;
  596. };
  597. typedef struct InterruptSetMember        InterruptSetMember;
  598.  
  599. enum {
  600.     kISTChipInterruptSource        = 0,
  601.     kISTOutputDMAInterruptSource = 1,
  602.     kISTInputDMAInterruptSource    = 2,
  603.     kISTPropertyMemberCount        = 3
  604. };
  605.  
  606.  
  607. typedef InterruptSetMember                 ISTProperty[3];
  608. #define kISTPropertyName    "driver-ist" 
  609.  
  610. typedef long                             InterruptReturnValue;
  611.  
  612. enum {
  613.     kFirstMemberNumber            = 1,
  614.     kIsrIsComplete                = 0,
  615.     kIsrIsNotComplete            = -1,
  616.     kMemberNumberParent            = -2
  617. };
  618.  
  619. typedef Boolean                         InterruptSourceState;
  620.  
  621. enum {
  622.     kSourceWasEnabled            = true,
  623.     kSourceWasDisabled            = false
  624. };
  625.  
  626.  
  627. typedef CALLBACK_API_C( InterruptMemberNumber , InterruptHandler )(InterruptSetMember ISTmember, void *refCon, UInt32 theIntCount);
  628. typedef CALLBACK_API_C( void , InterruptEnabler )(InterruptSetMember ISTmember, void *refCon);
  629. typedef CALLBACK_API_C( InterruptSourceState , InterruptDisabler )(InterruptSetMember ISTmember, void *refCon);
  630.  
  631. enum {
  632.     kReturnToParentWhenComplete    = 0x00000001,
  633.     kReturnToParentWhenNotComplete = 0x00000002
  634. };
  635.  
  636. typedef OptionBits                         InterruptSetOptions;
  637. /*  Interrupt Services  */
  638. EXTERN_API_C( OSStatus )
  639. CreateInterruptSet                (InterruptSetID         parentSet,
  640.                                  InterruptMemberNumber     parentMember,
  641.                                  InterruptMemberNumber     setSize,
  642.                                  InterruptSetID *        setID,
  643.                                  InterruptSetOptions     options);
  644.  
  645.  
  646. EXTERN_API_C( OSStatus )
  647. InstallInterruptFunctions        (InterruptSetID         setID,
  648.                                  InterruptMemberNumber     member,
  649.                                  void *                    refCon,
  650.                                  InterruptHandler         handlerFunction,
  651.                                  InterruptEnabler         enableFunction,
  652.                                  InterruptDisabler         disableFunction);
  653.  
  654.  
  655. EXTERN_API_C( OSStatus )
  656. GetInterruptFunctions            (InterruptSetID         setID,
  657.                                  InterruptMemberNumber     member,
  658.                                  void **                refCon,
  659.                                  InterruptHandler *        handlerFunction,
  660.                                  InterruptEnabler *        enableFunction,
  661.                                  InterruptDisabler *    disableFunction);
  662.  
  663. EXTERN_API_C( OSStatus )
  664. ChangeInterruptSetOptions        (InterruptSetID         setID,
  665.                                  InterruptSetOptions     options);
  666.  
  667. EXTERN_API_C( OSStatus )
  668. GetInterruptSetOptions            (InterruptSetID         setID,
  669.                                  InterruptSetOptions *    options);
  670.  
  671.  
  672.  
  673.  
  674. #if PRAGMA_STRUCT_ALIGN
  675.     #pragma options align=reset
  676. #elif PRAGMA_STRUCT_PACKPUSH
  677.     #pragma pack(pop)
  678. #elif PRAGMA_STRUCT_PACK
  679.     #pragma pack()
  680. #endif
  681.  
  682. #ifdef PRAGMA_IMPORT_OFF
  683. #pragma import off
  684. #elif PRAGMA_IMPORT
  685. #pragma import reset
  686. #endif
  687.  
  688. #ifdef __cplusplus
  689. }
  690. #endif
  691.  
  692. #endif /* __DRIVERSERVICES__ */
  693.  
  694.